import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import '../../../common/utils/toast_util.dart';

import 'dart:async';
import 'dart:developer' as developer;
import '../../../common/services/amap_location_service.dart'; // 🗺️ 启用高德地图定位服务
import '../../../common/services/permission_service.dart';

class SearchResult {
  final String title;
  final String subtitle;
  final double lat;
  final double lng;
  
  SearchResult({
    required this.title,
    this.subtitle = '',
    required this.lat,
    required this.lng,
  });
}

// 定位页面控制器
class MapPageController extends GetxController {
  final Map<String, dynamic>? initialArguments; // 🔥 新增：初始参数
  
  MapPageController({this.initialArguments}); // 🔥 修改构造函数
  
  // 服务依赖（启用高德定位）
  late AmapLocationService _amapLocationService; // 🗺️ 高德地图定位服务
  late PermissionService _permissionService;
  
  // 原生地图交互Channel（每个地图实例有独立的channel）
  MethodChannel? _mapChannel;
  bool _isMapReady = false;
  
  // 获取权限状态
  bool get isLocationPermissionGranted => _permissionService.isLocationPermissionGranted;
  
  // 🎯 获取页面模式状态（响应式访问器）
  RxBool get isViewModeRx => _isViewMode;
  RxBool get hasIncomingLocationRx => _hasIncomingLocation;
  
  // 🎯 获取页面模式状态（普通访问器）
  bool get isViewMode => _isViewMode.value;
  bool get hasIncomingLocation => _hasIncomingLocation.value;
  
  // 当前位置描述
  RxString currentLocation = "".obs;
  
  // 当前坐标 (默认中国中心位置，避免误导用户)
  RxDouble latitude = 35.0.obs;  // 中国地理中心大约位置
  RxDouble longitude = 105.0.obs;
  
  // 🎯 页面模式标记（响应式变量）
  RxBool _isViewMode = false.obs;  // 是否为查看模式（查看活动/评论位置）
  RxBool _hasIncomingLocation = false.obs;  // 是否有传入的位置参数
  
  // 搜索相关
  final searchController = TextEditingController();
  RxBool isSearching = false.obs;
  RxBool showSearchResults = false.obs;
  RxList<SearchResult> searchResults = <SearchResult>[].obs;
  RxList<SearchResult> allSearchData = <SearchResult>[].obs; // 存储所有搜索数据
  Timer? _debounce;

  @override
  void onInit() {
    super.onInit();
    
    // 初始化服务依赖（启用高德定位）
    _amapLocationService = Get.find<AmapLocationService>(); // 🗺️ 高德地图定位服务
    _permissionService = Get.find<PermissionService>();
    
    // 初始化搜索数据（但不显示）
    _initSearchData();
    
    // 🔥 直接处理构造函数传入的参数
    _handleIncomingLocationParamsInternal(initialArguments);
    
    developer.log('🗺️ MapPageController初始化完成', name: 'Map');
    developer.log('📊 初始化状态: isViewMode=${_isViewMode.value}, hasIncomingLocation=${_hasIncomingLocation.value}', name: 'Map');
    developer.log('📍 初始位置: lat=${latitude.value}, lng=${longitude.value}, location=${currentLocation.value}', name: 'Map');
  }
  
  @override
  void onReady() {
    super.onReady();
    
    developer.log('🔥 =============== MapPageController onReady ===============', name: 'Map');
    developer.log('🔍 onReady 状态检查:', name: 'Map');
    developer.log('   - 查看模式: ${_isViewMode.value}', name: 'Map');
    developer.log('   - 有传入位置: ${_hasIncomingLocation.value}', name: 'Map');
    developer.log('   - 当前位置: ${currentLocation.value}', name: 'Map');
    developer.log('   - 当前坐标: ${latitude.value}, ${longitude.value}', name: 'Map');
    
    // 🔥 设置初始状态（根据模式和传入参数决定）
    if (_isViewMode.value) {
      // 🎯 查看模式：显示传入的活动/评论位置，不进行用户定位
      developer.log('👁️ 查看模式初始化：将显示传入的活动/评论位置', name: 'Map');
      if (currentLocation.value.isEmpty) {
        currentLocation.value = "正在加载位置信息...";
      }
    } else if (!_hasIncomingLocation.value) {
      // 没有传入位置参数且非查看模式时，显示等待权限授予提示
      developer.log('📍 定位模式初始化：将获取用户当前位置', name: 'Map');
      if (currentLocation.value.isEmpty) {
        currentLocation.value = "等待权限授予...";
      }
    } else {
      // 有传入位置参数但非查看模式时，显示加载提示
      developer.log('📍 定位模式（有传入位置）初始化', name: 'Map');
      if (currentLocation.value.isEmpty) {
        currentLocation.value = "正在加载位置信息...";
      }
    }
    
    developer.log('🏁 =============== MapPageController onReady 完成 ===============', name: 'Map');
  }
  

  
  /// 🔥 内部参数处理方法（使用传入的参数而不依赖Get.arguments）
  void _handleIncomingLocationParamsInternal(Map<String, dynamic>? args) {
    try {
      developer.log('🔍 =============== 开始处理传入参数 ===============', name: 'Map');
      developer.log('🔍 传入参数: $args (类型: ${args.runtimeType})', name: 'Map');
      
      if (args != null && args.isNotEmpty) {
        developer.log('🎯 收到传入的地图参数: $args', name: 'Map');
        
        final address = args['address'] as String?;
        final lat = (args['latitude'] as num?)?.toDouble();
        final lng = (args['longitude'] as num?)?.toDouble();
        final title = args['title'] as String?;
        final showMode = args['showMode'] as bool? ?? false;
        
        developer.log('📊 参数解析结果:', name: 'Map');
        developer.log('   - address: $address', name: 'Map');
        developer.log('   - latitude: $lat', name: 'Map');
        developer.log('   - longitude: $lng', name: 'Map');
        developer.log('   - title: $title', name: 'Map');
        developer.log('   - showMode: $showMode', name: 'Map');
        
        // 🔥 首先设置查看模式状态（最高优先级）
        if (showMode) {
          _isViewMode.value = true;
          developer.log('👁️ ✅ 启用查看模式（查看活动/评论位置）- 不会执行用户定位', name: 'Map');
        }
        
        // 🔥 标记有传入位置参数
        if (address?.isNotEmpty == true || (lat != null && lng != null && (lat != 0.0 || lng != 0.0))) {
          _hasIncomingLocation.value = true;
          developer.log('✅ 检测到有效传入位置参数，将优先显示目标位置', name: 'Map');
        }
        
        if (address?.isNotEmpty == true) {
          currentLocation.value = address!;
          developer.log('📍 设置传入地址: $address', name: 'Map');
        }
        
        if (lat != null && lng != null && (lat != 0.0 || lng != 0.0)) {
          latitude.value = lat;
          longitude.value = lng;
          developer.log('🌐 设置传入坐标: $lat, $lng', name: 'Map');
          
          // 🗺️ 延迟移动地图到指定位置（等待地图初始化完成）
          Future.delayed(const Duration(milliseconds: 1500), () {
            moveMapToLocation(lat, lng);
          });
          
          // 🔥 在查看模式下，如果有坐标但地址为空或默认值，尝试逆地理编码获取详细地址
          if (_isViewMode.value && (address?.isEmpty == true || address?.contains('江苏省苏州市') == true)) {
            developer.log('🔄 查看模式下坐标有效，尝试获取详细地址', name: 'Map');
            Future.delayed(const Duration(milliseconds: 2000), () {
              _getDetailedAddressFromCoordinates(lat, lng);
            });
          }
        } else if (address?.isNotEmpty == true) {
          // 🔍 如果没有坐标但有地址，尝试搜索该地址（仅在查看模式下）
          if (_isViewMode.value) {
            developer.log('🔍 查看模式 - 没有坐标，将搜索地址: $address', name: 'Map');
            Future.delayed(const Duration(milliseconds: 1500), () {
              performSearch(address!);
            });
          } else {
            developer.log('🔍 非查看模式 - 没有坐标，但有地址: $address', name: 'Map');
          }
        }
        
        // 🎯 记录详细的模式信息
        if (_isViewMode.value) {
          final sourceType = title?.contains('活动') == true ? '活动' : '评论';
          developer.log('👁️ 查看模式详情: 来源=$sourceType, 标题=$title', name: 'Map');
        }
        
        developer.log('✅ 参数处理完成，最终状态:', name: 'Map');
        developer.log('   - 查看模式: ${_isViewMode.value}', name: 'Map');
        developer.log('   - 有传入位置: ${_hasIncomingLocation.value}', name: 'Map');
        developer.log('   - 当前位置: ${currentLocation.value}', name: 'Map');
        developer.log('   - 当前坐标: ${latitude.value}, ${longitude.value}', name: 'Map');
        
      } else {
        developer.log('ℹ️ 没有传入地图参数或参数为空，将请求用户当前位置', name: 'Map');
        _hasIncomingLocation.value = false;
        _isViewMode.value = false;
      }
    } catch (e) {
      developer.log('💥 处理传入参数异常: $e', name: 'Map');
      _hasIncomingLocation.value = false;
      _isViewMode.value = false;
    } finally {
      developer.log('🏁 =============== 传入参数处理完成 ===============', name: 'Map');
    }
  }
  
  @override
  void onClose() {
    try {
      developer.log('🗑️ =============== MapPageController正在销毁 ===============', name: 'Map');
      
      // 🔥 停止原生地图的所有监听和回调
      if (_mapChannel != null) {
        developer.log('🛑 停止原生地图监听器', name: 'Map');
        _mapChannel!.setMethodCallHandler(null);
        _mapChannel = null;
      }
      
      // 🔥 安全清理搜索相关资源
      try {
        if (_debounce?.isActive == true) {
          _debounce!.cancel();
          developer.log('✅ 清理搜索定时器', name: 'Map');
        }
        
        // 🔥 安全dispose搜索控制器
        try {
          searchController.dispose();
          developer.log('✅ 清理搜索控制器', name: 'Map');
        } catch (e) {
          developer.log('⚠️ 搜索控制器清理异常: $e', name: 'Map');
        }
      } catch (e) {
        developer.log('⚠️ 清理搜索资源时异常: $e', name: 'Map');
      }
      
      developer.log('✅ MapPageController资源清理完成', name: 'Map');
    } catch (e) {
      developer.log('💥 MapPageController销毁过程中出现异常: $e', name: 'Map');
    }
    
    super.onClose();
  }
  
  // 初始化搜索数据（使用真实定位数据）
  void _initSearchData() {
    // 不再预置模拟数据，使用真实的搜索API
    // 搜索结果将通过地图API动态获取
    developer.log('🗺️ 搜索数据初始化完成，等待用户搜索', name: 'Map');
  }
  
  // 搜索内容变化时的处理
  void onSearchChanged(String value) {
    if (_debounce?.isActive ?? false) _debounce!.cancel();
    
    _debounce = Timer(const Duration(milliseconds: 500), () {
      if (value.isNotEmpty) {
        performSearch(value);
      } else {
        showSearchResults.value = false;
      }
    });
  }
  
  // 搜索提交时的处理
  void onSearchSubmitted(String value) {
    if (value.isNotEmpty) {
      performSearch(value);
    }
  }
  
  // 执行搜索（使用真实地图API）
  void performSearch(String keyword) {
    isSearching.value = true;
    
    // 使用真实的地图搜索API
    _searchLocationsByKeyword(keyword);
  }
  
  // 使用原生地图API搜索位置（替换模拟搜索）
  Future<void> _searchLocationsByKeyword(String keyword) async {
    try {
      developer.log('🔍 开始搜索: $keyword', name: 'Map');
      
      // 🚀 使用原生高德POI搜索API（学习MyApplication2实现）
      await _searchWithNativeAPI(keyword);
      
    } catch (e) {
      developer.log('💥 搜索异常: $e', name: 'Map');
      _handleSearchError("搜索异常: $e");
    }
  }
  
  
  // 选择搜索结果
  void onSearchResultSelected(SearchResult result) {
    developer.log('📍 用户选择搜索结果: ${result.title}', name: 'Map');
    
    // 更新位置信息
    latitude.value = result.lat;
    longitude.value = result.lng;
    currentLocation.value = result.title + (result.subtitle.isNotEmpty ? ", ${result.subtitle}" : "");
    
    // 🗺️ 移动地图到选中位置（学习MyApplication2实现）
    moveMapToLocation(result.lat, result.lng);
    
    // 隐藏搜索结果界面
    showSearchResults.value = false;
    searchController.text = result.title;
    
    // 🎉 显示选择成功提示
    ToastUtil.success("已选择: ${result.title}");
    
    update();
  }
  
  // 智能定位策略（优先高德定位，降级到系统定位）
  Future<void> _getCurrentLocation() async {
    developer.log('🎯 =============== 开始智能定位 ===============', name: 'Map');
    developer.log('🔍 地图页面定位服务状态检查:', name: 'Map');
    developer.log('  🔧 AmapLocationService: $_amapLocationService', name: 'Map');
    developer.log('  🔧 PermissionService: $_permissionService', name: 'Map');
    
    try {
      // 🗺️ 策略1: 优先使用高德定位（与MyApplication2相同技术）
      developer.log('📍 尝试高德定位...', name: 'Map');
      currentLocation.value = "正在高德定位中...";
      
      developer.log('🚀 地图页面开始调用高德定位服务...', name: 'Map');
      final amapLocation = await _amapLocationService.startLocation(
        isOnceLocation: true,
        timeout: const Duration(seconds: 10),
      );
      developer.log('📬 地图页面高德定位服务返回结果: $amapLocation', name: 'Map');
      
      if (amapLocation != null && amapLocation.success) {
        // 高德定位成功
        latitude.value = amapLocation.latitude!;
        longitude.value = amapLocation.longitude!;
        
        // 构建详细的位置描述
        String locationDesc = _amapLocationService.formatAddress(amapLocation.address);
        String accuracyDesc = _amapLocationService.getAccuracyDescription(amapLocation.accuracy);
        currentLocation.value = "$locationDesc ($accuracyDesc)";
        
        developer.log('✅ 高德定位成功: ${latitude.value}, ${longitude.value}', name: 'Map');
        developer.log('📍 地址: ${amapLocation.address}', name: 'Map');
        developer.log('🎯 精度: ${amapLocation.accuracy}m', name: 'Map');
        
        update();
        
        // 🎉 显示成功提示
        ToastUtil.success("定位成功");
        
        return;
      }
      
      developer.log('⚠️ 高德定位失败，降级到系统定位', name: 'Map');
      if (amapLocation != null) {
        developer.log('❌ 高德定位错误: ${amapLocation.errorMessage} (${amapLocation.errorCode})', name: 'Map');
      } else {
        developer.log('❌ 高德定位结果为 null', name: 'Map');
      }
      
      // 策略2: 降级到系统定位
      await _fallbackToSystemLocation();
      
    } catch (e) {
      developer.log('💥 智能定位异常: $e', name: 'Map');
      developer.log('💥 异常类型: ${e.runtimeType}', name: 'Map');
      // 策略3: 最终使用默认位置
      _setDefaultLocation("定位失败: $e");
    } finally {
      developer.log('🏁 =============== 智能定位结束 ===============', name: 'Map');
    }
  }

  // 降级到系统定位（简化版本，仅设置默认位置）
  Future<void> _fallbackToSystemLocation() async {
    developer.log('🔄 高德定位失败，设置默认位置...', name: 'Map');
    _setDefaultLocation("高德定位失败");
  }

  // 设置默认位置（保底方案）
  void _setDefaultLocation(String reason) {
    developer.log('🏠 使用默认位置: $reason', name: 'Map');
    
    // 设置为烟台市（项目默认城市）
    latitude.value = 37.463822;
    longitude.value = 121.447935;
    currentLocation.value = "烟台市--莱山区 (默认位置 - $reason)";
    
    update();
    
    // 显示友好提示
    ToastUtil.info("已设置默认位置，您可以手动选择其他位置");
  }

  
  // 请求位置权限（使用完善的权限服务）
  Future<void> requestLocationPermission() async {
    developer.log('🔐 开始请求位置权限...', name: 'Map');
    
    try {
      // 使用完善的权限服务
      final isGranted = await _permissionService.requestLocationPermission();
      
      if (isGranted) {
        developer.log('✅ 位置权限获取成功', name: 'Map');
        // 权限获取成功，开始智能定位
        await _getCurrentLocation();
      } else {
        developer.log('❌ 位置权限被拒绝', name: 'Map');
        _setDefaultLocation("位置权限被拒绝");
      }
    } catch (e) {
      developer.log('💥 请求权限异常: $e', name: 'Map');
      _setDefaultLocation("权限请求失败: $e");
      
    }
  }
  
  // 从坐标更新位置信息（增强版：调用逆地理编码获取详细地址）
  void updateLocationFromCoordinates(double lat, double lng) {
    latitude.value = lat;
    longitude.value = lng;
    
    // 🎯 先显示坐标，然后异步获取详细地址
    final latStr = lat.toStringAsFixed(5);
    final lngStr = lng.toStringAsFixed(5);
    currentLocation.value = "正在解析位置 ($latStr, $lngStr)...";
    
    developer.log('📍 用户选择新位置: $latStr, $lngStr', name: 'Map');
    
    // 🌐 异步调用逆地理编码获取详细地址
    _getDetailedAddressFromCoordinates(lat, lng);
    
    update();
  }

  // 🌐 通过逆地理编码获取详细地址信息
  Future<void> _getDetailedAddressFromCoordinates(double lat, double lng) async {
    try {
      developer.log('🌐 开始逆地理编码获取详细地址: $lat, $lng', name: 'Map');
      
      // 在查看模式下，不要显示成功提示，避免干扰用户体验
      final isInViewMode = _isViewMode.value;
      
      // 调用高德定位服务的逆地理编码功能
      final geocodeResult = await _amapLocationService.reverseGeocode(lat, lng);
      
      if (geocodeResult != null && geocodeResult.success) {
        // 🎉 逆地理编码成功，显示详细地址
        String locationDesc = _amapLocationService.formatAddress(geocodeResult.address);
        String accuracyDesc = isInViewMode ? "位置信息" : "逆地理编码";
        currentLocation.value = "$locationDesc ($accuracyDesc)";
        
        developer.log('✅ 逆地理编码成功: ${geocodeResult.latitude}, ${geocodeResult.longitude}', name: 'Map');
        developer.log('📍 详细地址: ${geocodeResult.address}', name: 'Map');
        developer.log('🏙️ 行政区域: ${geocodeResult.province} ${geocodeResult.city} ${geocodeResult.district}', name: 'Map');
        
        // 🎯 非查看模式时显示成功提示
        if (!isInViewMode) {
          ToastUtil.success("获取地址信息成功");
        }
        
      } else {
        // ❌ 逆地理编码失败，显示坐标
        final latStr = lat.toStringAsFixed(5);
        final lngStr = lng.toStringAsFixed(5);
        currentLocation.value = isInViewMode ? "位置信息 ($latStr, $lngStr)" : "选中位置 ($latStr, $lngStr)";
        
        developer.log('❌ 逆地理编码失败: ${geocodeResult?.errorMessage}', name: 'Map');
        
        // 显示失败提示（但不太重要，不打扰用户）
        // ToastUtil.warning("获取地址详情失败，显示坐标");
      }
      
    } catch (e) {
      developer.log('💥 逆地理编码异常: $e', name: 'Map');
      
      // 异常时显示坐标
      final latStr = lat.toStringAsFixed(5);
      final lngStr = lng.toStringAsFixed(5);
      final isInViewMode = _isViewMode.value;
      currentLocation.value = isInViewMode ? "位置信息 ($latStr, $lngStr)" : "选中位置 ($latStr, $lngStr)";
    } finally {
      update();
    }
  }
  
  // 显示定位提示（帮助用户理解定位过程）
  void showLocationTips() {
    // Get.snackbar(
    //   "定位提示", 
    //   "首次定位需要几秒钟，请确保在开阔区域并已开启位置权限",
    //   snackPosition: SnackPosition.TOP,
    //   duration: Duration(seconds: 3),
    //   backgroundColor: Colors.blue.shade100,
    //   colorText: Colors.blue.shade800,
    //   margin: EdgeInsets.all(16),
    //   borderRadius: 8,
    // );
  }
  
  // ====================== 原生地图交互方法 ======================
  
  /// 设置地图Method Channel（当AndroidView创建后调用）
  void setMapChannel(int viewId) {
    try {
      final channelName = "com.playtruly.amap_map_$viewId";
      _mapChannel = MethodChannel(channelName);
      
      // 设置地图事件监听
      _mapChannel!.setMethodCallHandler(_handleMapCallback);
      _isMapReady = true;
      
      developer.log('🗺️ 地图Channel设置成功: $channelName', name: 'Map');
    } catch (e) {
      developer.log('💥 设置地图Channel失败: $e', name: 'Map');
    }
  }
  
  /// 处理来自原生地图的回调
  Future<void> _handleMapCallback(MethodCall call) async {
    try {
      // 🔥 检查Controller是否还存在（防止页面关闭后继续执行回调）
      if (!Get.isRegistered<MapPageController>()) {
        developer.log('⚠️ MapPageController已被删除，忽略原生回调: ${call.method}', name: 'Map');
        return;
      }
      
      developer.log('📞 收到原生地图回调: ${call.method}', name: 'Map');
      
      switch (call.method) {
        case 'onLocationChanged':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过位置更新', name: 'Map');
              return;
            }
            
            final data = call.arguments is Map
                ? Map<String, dynamic>.from(call.arguments as Map)
                : <String, dynamic>{};
            final lat = (data['latitude'] as num?)?.toDouble() ?? 0.0;
            final lng = (data['longitude'] as num?)?.toDouble() ?? 0.0;
            final address = data['address'] as String? ?? '位置信息获取失败';
            
            // 安全更新位置信息
            latitude.value = lat;
            longitude.value = lng;
            currentLocation.value = address;
            
            developer.log('📍 位置已更新: $lat, $lng - $address', name: 'Map');
            update();
          } catch (e) {
            developer.log('💥 处理位置变化回调异常: $e', name: 'Map');
          }
          break;
          
        case 'onAddressChanged':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过地址更新', name: 'Map');
              return;
            }
            
            final data = call.arguments is Map
                ? Map<String, dynamic>.from(call.arguments as Map)
                : <String, dynamic>{};
            final address = data['address'] as String? ?? '地址信息获取失败';
            
            currentLocation.value = address;
            developer.log('🏠 地址已更新: $address', name: 'Map');
            update();
          } catch (e) {
            developer.log('💥 处理地址变化回调异常: $e', name: 'Map');
          }
          break;
          
        case 'onLocationSuccess':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过定位成功处理', name: 'Map');
              return;
            }
            
            final data = call.arguments is Map
                ? Map<String, dynamic>.from(call.arguments as Map)
                : <String, dynamic>{};
            final lat = (data['latitude'] as num?)?.toDouble() ?? 0.0;
            final lng = (data['longitude'] as num?)?.toDouble() ?? 0.0;
            final address = data['address'] as String? ?? '位置信息获取失败';
            
            latitude.value = lat;
            longitude.value = lng;
            currentLocation.value = address;
            
            ToastUtil.success("定位成功");
            developer.log('✅ 原生定位成功: $lat, $lng - $address', name: 'Map');
            update();
          } catch (e) {
            developer.log('💥 处理定位成功回调异常: $e', name: 'Map');
            if (Get.isRegistered<MapPageController>()) {
              ToastUtil.error("定位数据处理失败");
            }
          }
          break;
          
        case 'onLocationError':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过定位错误处理', name: 'Map');
              return;
            }
            
            final errorMessage = call.arguments as String? ?? '未知定位错误';
            ToastUtil.error("定位失败: $errorMessage");
            developer.log('❌ 原生定位失败: $errorMessage', name: 'Map');
          } catch (e) {
            developer.log('💥 处理定位错误回调异常: $e', name: 'Map');
            if (Get.isRegistered<MapPageController>()) {
              ToastUtil.error("定位失败");
            }
          }
          break;
          
        // ====================== POI搜索回调处理 ======================
        case 'onSearchSuccess':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过搜索成功处理', name: 'Map');
              return;
            }
            
            // 安全地转换搜索结果数据类型
            final rawData = call.arguments;
            List<Map<String, dynamic>> searchData;
            
            if (rawData is List) {
              searchData = rawData.map<Map<String, dynamic>>((item) {
                if (item is Map) {
                  return Map<String, dynamic>.from(item);
                }
                return <String, dynamic>{};
              }).toList();
            } else {
              searchData = <Map<String, dynamic>>[];
            }
            
            developer.log('📞 收到原生地图回调: onSearchSuccess，数据类型: ${rawData.runtimeType}', name: 'Map');
            _handleSearchSuccess(searchData);
          } catch (e) {
            developer.log('💥 处理搜索成功回调时类型转换异常: $e', name: 'Map');
            if (Get.isRegistered<MapPageController>()) {
              _handleSearchError("搜索结果数据格式异常");
            }
          }
          break;
          
        case 'onSearchError':
          try {
            // 🔥 再次检查Controller状态
            if (!Get.isRegistered<MapPageController>()) {
              developer.log('⚠️ Controller已删除，跳过搜索错误处理', name: 'Map');
              return;
            }
            
            final errorMessage = call.arguments as String? ?? '未知搜索错误';
            _handleSearchError(errorMessage);
          } catch (e) {
            developer.log('💥 处理搜索错误回调异常: $e', name: 'Map');
            if (Get.isRegistered<MapPageController>()) {
              _handleSearchError("搜索发生异常");
            }
          }
          break;
      }
    } catch (e) {
      developer.log('💥 处理地图回调异常: $e', name: 'Map');
    }
  }
  
  /// 移动地图到指定位置 - 🔥 优化：异步执行避免主线程阻塞
  Future<void> moveMapToLocation(double lat, double lng) async {
    if (!_isMapReady || _mapChannel == null) {
      developer.log('⚠️ 地图未准备就绪，无法移动位置', name: 'Map');
      return;
    }
    
    try {
      developer.log('📍 开始移动地图到: $lat, $lng', name: 'Map');
      
      // 🔥 使用异步执行，避免阻塞主线程
      Future.microtask(() async {
        try {
          await _mapChannel!.invokeMethod('moveToLocation', {
            'latitude': lat,
            'longitude': lng,
          });
          developer.log('✅ 地图移动完成: $lat, $lng', name: 'Map');
        } catch (e) {
          developer.log('💥 移动地图失败: $e', name: 'Map');
        }
      });
      
    } catch (e) {
      developer.log('💥 移动地图异常: $e', name: 'Map');
    }
  }
  
  /// 获取当前地图位置
  Future<Map<String, dynamic>?> getCurrentMapLocation() async {
    if (!_isMapReady || _mapChannel == null) {
      developer.log('⚠️ 地图未准备就绪，无法获取位置', name: 'Map');
      return null;
    }
    
    try {
      final result = await _mapChannel!.invokeMethod('getCurrentLocation');
      return Map<String, dynamic>.from(result);
    } catch (e) {
      developer.log('💥 获取地图位置失败: $e', name: 'Map');
      return null;
    }
  }
  
  /// 触发原生地图定位
  Future<void> startMapLocationSelf() async {
    if (!_isMapReady || _mapChannel == null) {
      developer.log('⚠️ 地图未准备就绪，无法开始定位', name: 'Map');
      ToastUtil.warning("地图加载中，请稍后重试");
      return;
    }
    
    try {
      currentLocation.value = "正在定位中...";
      await _mapChannel!.invokeMethod('startLocationSelf');
      
      developer.log('🎯 原生地图定位已启动', name: 'Map');
    } catch (e) {
      developer.log('💥 启动原生地图定位失败: $e', name: 'Map');
      ToastUtil.error("定位启动失败");
    }
  }

  // 权限被授予时调用
  void onPermissionGranted() {
    developer.log('🎉 权限已授予', name: 'Map');
    developer.log('🔍 权限授予时状态检查:', name: 'Map');
    developer.log('   - 查看模式: ${_isViewMode.value}', name: 'Map');
    developer.log('   - 有传入位置: ${_hasIncomingLocation.value}', name: 'Map');
    developer.log('   - 当前位置: ${currentLocation.value}', name: 'Map');
    
    // 🔥 检查是否为查看模式（活动/评论位置）
    if (_isViewMode.value) {
      developer.log('👁️ 查看模式：不执行用户定位，显示传入的活动/评论位置', name: 'Map');
      developer.log('👁️ 查看模式详情: 纬度=${latitude.value}, 经度=${longitude.value}', name: 'Map');
      return;
    }
    
    // 🔥 只有在没有传入位置参数且非查看模式时才执行定位逻辑
    if (!_hasIncomingLocation.value) {
      developer.log('📍 没有传入位置参数，开始获取用户当前位置', name: 'Map');
      
      // 更新状态
      currentLocation.value = "正在定位中，请稍候...";
      
      // 显示定位提示
      showLocationTips();
      
      // 优先使用原生地图定位，如果失败则降级到高德定位服务
      if (_isMapReady && _mapChannel != null) {
        developer.log('📍 使用原生地图定位', name: 'Map');
        startMapLocationSelf();
      } else {
        developer.log('📍 地图未就绪，使用高德定位服务', name: 'Map');
        _getCurrentLocation();
      }
    } else {
      developer.log('✅ 已有传入位置参数，跳过当前位置获取', name: 'Map');
      developer.log('✅ 传入位置详情: 纬度=${latitude.value}, 经度=${longitude.value}', name: 'Map');
    }
  }
  
  // ====================== POI搜索功能实现（对接原生API） ======================
  
  /// 处理搜索成功回调
  void _handleSearchSuccess(List<Map<String, dynamic>> searchData) {
    try {
      developer.log('✅ 收到搜索成功回调，结果数量: ${searchData.length}', name: 'Map');
      
      List<SearchResult> results = searchData.map((item) {
        return SearchResult(
          title: item['title'] as String? ?? '未知位置',
          subtitle: '${item['snippet'] as String? ?? ''}${item['cityName'] != null ? ' · ${item['cityName']}' : ''}',
          lat: (item['latitude'] as num?)?.toDouble() ?? 0.0,
          lng: (item['longitude'] as num?)?.toDouble() ?? 0.0,
        );
      }).toList();
      
      searchResults.value = results;
      showSearchResults.value = true;
      
      developer.log('📋 搜索结果已更新，共${results.length}个结果', name: 'Map');
      
    } catch (e) {
      developer.log('💥 处理搜索成功回调异常: $e', name: 'Map');
      ToastUtil.error("搜索结果处理失败");
    } finally {
      isSearching.value = false;
    }
  }
  
  /// 处理搜索失败回调
  void _handleSearchError(String errorMessage) {
    try {
      developer.log('❌ 收到搜索失败回调: $errorMessage', name: 'Map');
      
      searchResults.clear();
      showSearchResults.value = false;
      
      // 🔥 在查看模式下，搜索失败不应该触发用户定位
      if (_isViewMode.value) {
        developer.log('👁️ 查看模式下搜索失败，不执行用户定位', name: 'Map');
        ToastUtil.warning("位置搜索失败: $errorMessage");
        currentLocation.value = "位置信息获取失败";
      } else {
        ToastUtil.show("搜索失败: $errorMessage");
      }
      
    } catch (e) {
      developer.log('💥 处理搜索失败回调异常: $e', name: 'Map');
    } finally {
      isSearching.value = false;
    }
  }
  
  /// 调用原生POI搜索
  Future<void> _searchWithNativeAPI(String keyword) async {
    if (!_isMapReady || _mapChannel == null) {
      developer.log('⚠️ 地图未准备就绪，无法进行搜索', name: 'Map');
      
      // 🔥 在查看模式下，地图未就绪时不要引导用户等待，而是显示错误
      if (_isViewMode.value) {
        developer.log('👁️ 查看模式下地图未就绪，显示位置加载失败', name: 'Map');
        ToastUtil.error("位置信息加载失败，地图未就绪");
        currentLocation.value = "位置信息加载失败";
      } else {
        ToastUtil.warning("地图加载中，请稍后重试");
      }
      
      isSearching.value = false;
      return;
    }
    
    try {
      developer.log('🔍 调用原生搜索API: $keyword', name: 'Map');
      
      // 获取搜索城市（可以从当前位置或用户设置中获取）
      String searchCity = "烟台市"; // 默认城市，可以根据当前位置动态获取
      
      await _mapChannel!.invokeMethod('searchPOI', {
        'keyword': keyword,
        'city': searchCity,
      });
      
      developer.log('📤 搜索请求已发送到原生层', name: 'Map');
      
    } catch (e) {
      developer.log('💥 调用原生搜索异常: $e', name: 'Map');
      _handleSearchError("搜索请求失败: $e");
    }
  }
}
